home *** CD-ROM | disk | FTP | other *** search
/ Inter.Net 55-1 / Inter.Net 55-1.iso / CBuilder / Setup / BCB / data.z / numeric.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-02-09  |  7.3 KB  |  218 lines
  1. #ifndef __STD_NUMERIC
  2. #define __STD_NUMERIC
  3. #pragma option push -b -a4 -Vx- -Ve- -w-inl -w-aus -w-sig
  4.  
  5. /***************************************************************************
  6.  *
  7.  * numeric - Declarations for the Standard Library algorithms
  8.  *
  9.  * $Id: numeric,v 1.8 1996/08/28 01:29:37 smithey Exp $
  10.  *
  11.  ***************************************************************************
  12.  *
  13.  * Copyright (c) 1994
  14.  * Hewlett-Packard Company
  15.  *
  16.  * Permission to use, copy, modify, distribute and sell this software
  17.  * and its documentation for any purpose is hereby granted without fee,
  18.  * provided that the above copyright notice appear in all copies and
  19.  * that both that copyright notice and this permission notice appear
  20.  * in supporting documentation.  Hewlett-Packard Company makes no
  21.  * representations about the suitability of this software for any
  22.  * purpose.  It is provided "as is" without express or implied warranty.
  23.  *
  24.  *
  25.  ***************************************************************************
  26.  *
  27.  * (c) Copyright 1994, 1995 Rogue Wave Software, Inc.
  28.  * ALL RIGHTS RESERVED *
  29.  * The software and information contained herein are proprietary to, and
  30.  * comprise valuable trade secrets of, Rogue Wave Software, Inc., which
  31.  * intends to preserve as trade secrets such software and information.
  32.  * This software is furnished pursuant to a written license agreement and
  33.  * may be used, copied, transmitted, and stored only in accordance with
  34.  * the terms of such license and with the inclusion of the above copyright
  35.  * notice.  This software and information or any other copies thereof may
  36.  * not be provided or otherwise made available to any other person.
  37.  *
  38.  * Notwithstanding any other lease or license that may pertain to, or
  39.  * accompany the delivery of, this computer software and information, the
  40.  * rights of the Government regarding its use, reproduction and disclosure
  41.  * are as set forth in Section 52.227-19 of the FARS Computer
  42.  * Software-Restricted Rights clause.
  43.  * 
  44.  * Use, duplication, or disclosure by the Government is subject to
  45.  * restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in
  46.  * Technical Data and Computer Software clause at DFARS 252.227-7013.
  47.  * Contractor/Manufacturer is Rogue Wave Software, Inc.,
  48.  * P.O. Box 2328, Corvallis, Oregon 97339.
  49.  *
  50.  * This computer software and information is distributed with "restricted
  51.  * rights."  Use, duplication or disclosure is subject to restrictions as
  52.  * set forth in NASA FAR SUP 18-52.227-79 (April 1985) "Commercial
  53.  * Computer Software-Restricted Rights (April 1985)."  If the Clause at
  54.  * 18-52.227-74 "Rights in Data General" is specified in the contract,
  55.  * then the "Alternate III" clause applies.
  56.  *
  57.  **************************************************************************/
  58.  
  59. #include <stdcomp.h>
  60.  
  61. #ifndef _RWSTD_HEADER_REQUIRES_HPP
  62. #include <functional>
  63. #include <iterator>
  64. #else
  65. #include <functional.hpp>
  66. #include <iterator.hpp>
  67. #endif 
  68.  
  69. #ifndef _RWSTD_NO_NEW_HEADER
  70. #include <cstdlib>
  71. #else
  72. #include <stdlib.h>
  73. #endif
  74.  
  75. #ifndef _RWSTD_NO_NAMESPACE
  76. namespace std {
  77. #endif
  78.  
  79. template <class InputIterator, class T>
  80. T accumulate (InputIterator first, InputIterator last, T init)
  81. {
  82.     while (first != last) init = init + *first++;
  83.     return init;
  84. }
  85.  
  86. template <class InputIterator, class T, class BinaryOperation>
  87. T accumulate (InputIterator first, InputIterator last, T init,
  88.           BinaryOperation binary_op)
  89. {
  90.     while (first != last) init = binary_op(init, *first++);
  91.     return init;
  92. }
  93.  
  94. template <class InputIterator1, class InputIterator2, class T>
  95. T inner_product (InputIterator1 first1, InputIterator1 last1,
  96.          InputIterator2 first2, T init)
  97. {
  98.     while (first1 != last1) init = init + (*first1++ * *first2++);
  99.     return init;
  100. }
  101.  
  102. template <class InputIterator1, class InputIterator2, class T,
  103.       class BinaryOperation1, class BinaryOperation2>
  104. T inner_product (InputIterator1 first1, InputIterator1 last1,
  105.          InputIterator2 first2, T init, BinaryOperation1 binary_op1,
  106.          BinaryOperation2 binary_op2)
  107. {
  108.     while (first1 != last1) 
  109.     init = binary_op1(init, binary_op2(*first1++, *first2++));
  110.     return init;
  111. }
  112.  
  113. template <class InputIterator, class OutputIterator, class T>
  114. OutputIterator __partial_sum (InputIterator first, InputIterator last,
  115.                   OutputIterator result, T*)
  116. {
  117.     T value = *first;
  118.     while (++first != last)
  119.     {
  120.     value = value + *first;
  121.     *++result = value;
  122.     }
  123.     return ++result;
  124. }
  125.  
  126. template <class InputIterator, class OutputIterator>
  127. inline OutputIterator partial_sum (InputIterator first, InputIterator last,
  128.                                    OutputIterator result)
  129. {
  130.     return first == last ? result :
  131.         (*result = *first,
  132.         __partial_sum(first, last, result, _RWSTD_VALUE_TYPE(first)));
  133. }
  134.  
  135. template <class InputIterator, class OutputIterator, class T,
  136.       class BinaryOperation>
  137. OutputIterator __partial_sum (InputIterator first, InputIterator last,
  138.                   OutputIterator result, T*,
  139.                   BinaryOperation binary_op)
  140. {
  141.     T value = *first;
  142.     while (++first != last)
  143.     {
  144.     value = binary_op(value, *first);
  145.     *++result = value;
  146.     }
  147.     return ++result;
  148. }
  149.  
  150. template <class InputIterator, class OutputIterator, class BinaryOperation>
  151. inline OutputIterator partial_sum (InputIterator first, InputIterator last,
  152.                                    OutputIterator result,
  153.                                    BinaryOperation binary_op)
  154. {
  155.     return first == last ? result :
  156.         (*result = *first,
  157.         __partial_sum(first, last, result, _RWSTD_VALUE_TYPE(first),binary_op));
  158. }
  159.  
  160. template <class InputIterator, class OutputIterator, class T>
  161. OutputIterator __adjacent_difference (InputIterator first, InputIterator last, 
  162.                       OutputIterator result, T*)
  163. {
  164.     T value = *first;
  165.     while (++first != last)
  166.     {
  167.     T tmp = *first;
  168.     *++result = tmp - value;
  169.     value = tmp;
  170.     }
  171.     return ++result;
  172. }
  173.  
  174. template <class InputIterator, class OutputIterator>
  175. inline OutputIterator adjacent_difference (InputIterator first,
  176.                                            InputIterator last, 
  177.                                            OutputIterator result)
  178. {
  179.     return first == last ? result :
  180.         (*result = *first,
  181.         __adjacent_difference(first, last, result, _RWSTD_VALUE_TYPE(first)));
  182. }
  183.  
  184. template <class InputIterator, class OutputIterator, class T, 
  185.       class BinaryOperation>
  186. OutputIterator __adjacent_difference (InputIterator first, InputIterator last, 
  187.                       OutputIterator result, T*,
  188.                       BinaryOperation binary_op)
  189. {
  190.     T value = *first;
  191.     while (++first != last)
  192.     {
  193.     T tmp = *first;
  194.     *++result = binary_op(tmp, value);
  195.     value = tmp;
  196.     }
  197.     return ++result;
  198. }
  199.  
  200. template <class InputIterator, class OutputIterator, class BinaryOperation>
  201. inline OutputIterator adjacent_difference (InputIterator first,
  202.                                            InputIterator last,
  203.                                            OutputIterator result,
  204.                                            BinaryOperation binary_op)
  205. {
  206.     return first == last ? result :
  207.         (*result = *first,
  208.         __adjacent_difference(first, last, result, _RWSTD_VALUE_TYPE(first),
  209.                               binary_op));
  210. }
  211.  
  212. #ifndef _RWSTD_NO_NAMESPACE
  213. }
  214. #endif
  215.  
  216. #pragma option pop
  217. #endif /* __STD_NUMERIC */
  218.